#pragma once

#include "db.hpp"
#include "online.hpp"
#include "room.hpp"
#include "matcher.hpp"
#include "session.hpp"
#include "util.hpp"

#define WWWROOT "./wwwroot/"

class gobang_server
{
public:
    gobang_server(const std::string &host, const std::string &username, const std::string &password,
                const std::string &dbname, uint16_t port = 3306, const std::string &wwwroot = WWWROOT):
        _web_root(wwwroot), _ut(host, username, password, dbname, port),
        _rm(&_ut, &_om), _sm(&_wsserver), _mm(&_rm, &_ut, &_om) 
    {
        // 1. 进行成员初始化
        _wsserver.set_access_channels(websocketpp::log::alevel::none); // 设置日志等级
        _wsserver.init_asio(); // 初始化asio调度器
        _wsserver.set_reuse_addr(true); // 设置地址重用
        // 2. 设置回调函数
        _wsserver.set_http_handler(std::bind(&gobang_server::http_callback, this, std::placeholders::_1));
        _wsserver.set_open_handler(std::bind(&gobang_server::wsopen_callback, this, std::placeholders::_1));
        _wsserver.set_close_handler(std::bind(&gobang_server::wsclose_callback, this, std::placeholders::_1));
        _wsserver.set_message_handler(std::bind(&gobang_server::wsmsg_callback, this, std::placeholders::_1, std::placeholders::_2));
    }
    ~gobang_server(){}

    // 启动服务器
    void start(int port)
    {
        _wsserver.listen(port); // 监听端口号
        _wsserver.start_accept(); // 获取新连接
        _wsserver.run(); // 启动服务器
    }

private:
    // 静态资源请求的处理
    void file_handler(wsserver_t::connection_ptr& conn)
    {
        // 1. 获取到请求uri资源路径，就是客户端请求的页面文件名称
        websocketpp::http::parser::request request = conn->get_request();
        std::string uri = request.get_uri();
        // 2. 组合出文件的实际路径：相对路径+uri
        std::string realpath = _web_root + uri;
        // 3. 如果请求的是个目录，增加一个后缀 login.hmtl
        if (realpath.back() == '/') {
            realpath += "login.html";
        }
        // 4. 读取文件内容
        Json::Value response;
        std::string body;
        bool ret = file_util::read(realpath, body);
        if (ret == false) {
            // 文件不存在，读取文件失败，返回404
            body += "<html>";
            body += "<head>";
            body += "<meta charset='UTF-8'/>";
            body += "</head>";
            body += "<body>";
            body += "<h1> Not Found </h1>";
            body += "</body>";
            conn->set_status(websocketpp::http::status_code::not_found);
            conn->set_body(body);
            return;
        }
        // 5. 设置响应正文
        conn->set_status(websocketpp::http::status_code::ok);
        conn->set_body(body);
    }
    // 设置http响应结果
    void http_response(wsserver_t::connection_ptr& conn, bool result, 
                    websocketpp::http::status_code::value code, const std::string& reason)
    {
        Json::Value response;
        response["result"] = result;
        response["reason"] = reason;
        std::string body;
        json_util::serialize(response, body); // 对响应正文序列化
        conn->set_status(code);
        conn->append_header("Content-Type", "application/json"); // 正文是json格式的数据
        conn->set_body(body);
    }
    // 用户注册请求功能的处理
    void reg(wsserver_t::connection_ptr& conn)
    {
        // 1. 获取http请求正文
        std::string req_body = conn->get_request_body();
        // 2. 对正文进行序列化，得到json格式的用户名和密码
        Json::Value reg_info;
        bool ret = json_util::unserialize(req_body, reg_info);
        if (ret == false) { // 失败时返回400
            DLOG("反序列化注册信息失败");
            return http_response(conn, false, websocketpp::http::status_code::bad_request, "请求的正文格式错误");
        }
        // 3. 进行数据库用户新增操作
        if (reg_info["username"].isNull() || reg_info["password"].isNull()) {
            DLOG("用户名密码不完整");
            return http_response(conn, false, websocketpp::http::status_code::bad_request, "请输入用户名/密码");
        }
        ret = _ut.insert(reg_info);
        if (ret == false) {
            DLOG("向数据库插入信息失败");
            return http_response(conn, false, websocketpp::http::status_code::bad_request, "用户名已经被占用");
        }
        // 成功返回200
        return http_response(conn, true, websocketpp::http::status_code::ok, "注册用户成功");
    }
    // 用户登入请求功能的处理
    void login(wsserver_t::connection_ptr& conn)
    {
        // 1. 获取请求正文，并进行json反序列化，得到用户名和密码
        std::string req_body = conn->get_request_body();
        Json::Value login_info;
        bool ret = json_util::unserialize(req_body, login_info);
        if (ret == false) {
            DLOG("反序列化登入信息失败");
            return http_response(conn, false, websocketpp::http::status_code::bad_request, "请求的正文格式错误");
        }
        // 2. 验证正文的完整性，进行数据库用户信息验证
        if (login_info["username"].isNull() || login_info["password"].isNull()) {
            DLOG("用户名密码不完整");
            return http_response(conn, false, websocketpp::http::status_code::bad_request, "请输入用户名/密码");
        }
        ret = _ut.login(login_info);
        if (ret == false) {
            DLOG("用户名密码错误"); // 如果验证失败，则返回400
            return http_response(conn, false, websocketpp::http::status_code::bad_request, "用户名/密码错误");
        }
        // 3. 给客户端创建session
        uint64_t uid = login_info["id"].asUInt64();
        session_ptr ssp = _sm.create_session(uid, LOGIN);
        if (ssp.get() == nullptr) {
            DLOG("创建会话");
            return http_response(conn, false, websocketpp::http::status_code::internal_server_error, "创建会话失败");
        }
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
        // 4. 设置响应头部 Set-Cookie，将session id通过cookie返回
        std::string cookie_ssid = "SSID=" + std::to_string(ssp->ssid());
        conn->append_header("Set-Cookie", cookie_ssid);
        return http_response(conn, true, websocketpp::http::status_code::ok, "登入成功");
    }
    // 从请求头Cookie字段中获取ssid
    bool get_cookie_val(const std::string& cookie, const std::string& key, std::string& val)
    {
        // Cookie: SSID=XXX; path=/;
        // 1. 以; 作为间隔对字符串进行分割，得到单个的Cookie信息
        std::string sep = "; ";
        std::vector<std::string> cookie_arr;
        string_util::split(cookie, sep, cookie_arr);
        for (auto str : cookie_arr) {
            // 2. 对单个的Cookie信息，以=作为间隔对字符串进行分割，得到key和value
            std::vector<std::string> tmp;
            string_util::split(str, "=", tmp);
            if (tmp.size() != 2) {
                continue;
            }
            if (tmp[0] == key) {
                val = tmp[1];
                return true;
            }
        }
        return false;
    }
    // 用户信息获取功能请求的处理
    void info(wsserver_t::connection_ptr& conn)
    {
        // 1. 获取请求信息中的Cookie
        std::string cookie = conn->get_request_header("Cookie");
        if (cookie.empty()) {
            // 如果没有Cookie，返回错误：没有Cookie信息，让客户端重新登入
            return http_response(conn, true, websocketpp::http::status_code::bad_request, "找不到Cookie信息, 请重新登入");
        }
        // 2. 从Cookie中获取ssid
        std::string ssid;
        bool ret = get_cookie_val(cookie, "SSID", ssid);
        if (ret == false) {
            // Cookie中没有ssid，返回错误：没有Cookie信息，让客户端重新登入
            return http_response(conn, true, websocketpp::http::status_code::bad_request, "找不到Cookie中的ssid信息, 请重新登入");
        }
        // 3. 在session管理中查找对应的会话信息
        session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid));
        if (ssp.get() == nullptr) {
            // 如果没有session，则认为登入已经过期，让客户端重新登入
            return http_response(conn, true, websocketpp::http::status_code::bad_request, "找不到Session信息(登入过期), 请重新登入");
        }
        // 4. 从数据库中取出用户信息，进行序列化发送给客户端
        uint64_t uid = ssp->get_user();
        Json::Value user_info;
        ret = _ut.select_by_id(uid, user_info);
        if (ret == false) {
            // 获取用户信息失败，返回错误：找不到用户信息
            return http_response(conn, true, websocketpp::http::status_code::bad_request, "找不到用户信息信息, 请重新登入");
        }
        std::string body;
        json_util::serialize(user_info, body);
        conn->append_header("Content-Type", "application/json");
        conn->set_status(websocketpp::http::status_code::ok);
        conn->set_body(body);
        // 5. 刷新session的过期时间
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
    }
    // http短连接建立成功的回调函数
    void http_callback(websocketpp::connection_hdl hdl)
    {
        // 1. 获取连接和http请求对象
        wsserver_t::connection_ptr conn = _wsserver.get_con_from_hdl(hdl);
        websocketpp::http::parser::request request = conn->get_request();
        // 2. 获取请求方法和uri，拼接请求文件的路径
        std::string method = request.get_method();
        std::string uri = request.get_uri();
        // 3. 不同的请求调用不同的业务函数进行处理
        if (method == "POST" && uri == "/reg") {
            return reg(conn); // 注册请求
        } else if (method == "POST" && uri == "/login") {
            return login(conn); // 登入请求
        } else if (method == "GET" && uri == "/info") {
            return info(conn); // 获取用户信息请求
        } else {
            return file_handler(conn); // 静态信息请求
        }
    }
    // websocket长连接响应结果
    void ws_response(wsserver_t::connection_ptr& conn, Json::Value& response)
    {
        std::string body;
        json_util::serialize(response, body);
        conn->send(body);
    }
    // 通过cookie来获取session
    session_ptr get_session_by_cookie(wsserver_t::connection_ptr& conn)
    {
        // 1. 获取请求信息中的Cookie
        Json::Value response;
        std::string cookie = conn->get_request_header("Cookie");
        if (cookie.empty()) {
            // 如果没有Cookie，返回错误：没有Cookie信息，让客户端重新登入
            response["optype"] = "hall_ready";
            response["reason"] = "找不到Cookie信息, 请重新登入";
            response["result"] = false;
            ws_response(conn, response);
            return session_ptr();
        }
        // 2. 从Cookie中获取ssid
        std::string ssid;
        bool ret = get_cookie_val(cookie, "SSID", ssid);
        if (ret == false) {
            // Cookie中没有ssid，返回错误：没有Cookie信息，让客户端重新登入
            response["optype"] = "hall_ready";
            response["reason"] = "找不到Cookie中的ssid信息, 请重新登入";
            response["result"] = false;
            ws_response(conn, response);
            return session_ptr();
        }
        // 3. 在session管理中查找对应的会话信息
        session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid));
        if (ssp.get() == nullptr) {
            // 如果没有session，则认为登入已经过期，让客户端重新登入
            response["optype"] = "hall_ready";
            response["reason"] = "找不到Session信息(登入过期), 请重新登入";
            response["result"] = false;
            ws_response(conn, response);
            return session_ptr();
        }
        return ssp;
    }
    // 游戏大厅websocket长连接建立成功处理
    void wsopen_game_hall(wsserver_t::connection_ptr& conn)
    {
        // 1. 判断当前客户端是否已经登入成功
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr) {
            return;
        }
        // 2. 判断当前客户端是否重复登入，不能在不同地方登入两次
        Json::Value response;
        if (_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user())) {
            response["optype"] = "hall_ready";
            response["reason"] = "玩家重复登入";
            response["result"] = false;
            return ws_response(conn, response);
        }
        // 3. 将当前客户端以及连接加入到游戏大厅
        _om.enter_game_hall(ssp->get_user(), conn);
        // 4. 给客户端响应游戏大厅连接建立成功
        response["optype"] = "hall_ready";
        response["result"] = true;
        ws_response(conn, response);
        // 5. 将session设置为永久存在
        _sm.set_session_expire_time(ssp->ssid(), SESSION_FOREVER);
    }
    // 游戏房间websocket长连接建立成功处理
    void wsopen_game_room(wsserver_t::connection_ptr& conn)
    {
        // 1. 获取当前客户端的session
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr) {
            return;
        }
        // 2. 当前用户是否在在线用户管理的，游戏大厅或游戏房间中
        Json::Value response;
        if (_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user())) {
            response["optype"] = "room_ready";
            response["reason"] = "玩家重复登入";
            response["result"] = false;
            return ws_response(conn, response);
        }
        // 3. 判断当前用户是否已经创建好了房间
        room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
        if (rp.get() == nullptr) {
            response["optype"] = "room_ready";
            response["reason"] = "未找到玩家的房间信息";
            response["result"] = false;
            return ws_response(conn, response);
        }
        // 4. 将当前用户添加到在线用户管理的游戏房间中
        _om.enter_game_room(ssp->get_user(), conn);
        // 5. 将session重新设置为永久存在
        _sm.set_session_expire_time(ssp->ssid(), SESSION_FOREVER);
        // 6. 回复房间准备完毕
        response["optype"] = "room_ready";
        response["result"] = true;
        response["room_id"] = rp->id();
        response["uid"] = ssp->get_user();
        response["white_id"] = rp->get_white_user();
        response["black_id"] = rp->get_black_user();;
        return ws_response(conn, response);
    }
    // websocket长连接建立成功的回调函数
    void wsopen_callback(websocketpp::connection_hdl hdl)
    {
	    wsserver_t::connection_ptr conn = _wsserver.get_con_from_hdl(hdl);
        websocketpp::http::parser::request request = conn->get_request();
        std::string uri = request.get_uri();
        if (uri == "/hall") {
            // 游戏大厅websocket长连接建立成功处理
            return wsopen_game_hall(conn);
        } else if (uri == "/room") {
            // 游戏房间websocket长连接建立成功处理
            return wsopen_game_room(conn);
        }
    }
    // 游戏大厅websocket长连接断开处理
    void wsclose_game_hall(wsserver_t::connection_ptr& conn)
    {
        // 1. 判断当前客户端是否已经登入成功
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr) {
            return;
        }
        // 2. 将玩家从游戏大厅中移除
        _om.exit_game_hall(ssp->get_user());
        // 3. 将session恢复生命周期的管理，设置定时销毁
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
    }
    // 游戏房间websocket长连接断开处理
    void wsclose_game_room(wsserver_t::connection_ptr& conn)
    {
        // 1. 获取会话信息来识别客户端
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr) {
            return;
        }
        // 2. 将玩家从在线用户的房间中移除
        _om.exit_game_room(ssp->get_user());
        // 3. 将session回复声明周期的管理，设置定时销毁
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
        // 4. 将玩家从房间中移除，房间中所有用户退出了就会销毁房间
        _rm.remove_room_user(ssp->get_user());
    }
    // websocket长连接断开的回调函数
    void wsclose_callback(websocketpp::connection_hdl hdl)
    {
        wsserver_t::connection_ptr conn = _wsserver.get_con_from_hdl(hdl);
        websocketpp::http::parser::request request = conn->get_request();
        std::string uri = request.get_uri();
        if (uri == "/hall") {
            // 游戏大厅websocket长连接断开处理
            return wsclose_game_hall(conn);
        } else if (uri == "/room") {
            // 游戏房间websocket长连接断开处理
            return wsclose_game_room(conn);
        }
    }
    // 游戏大厅websocket长连接收到消息处理
    void wsmsg_game_hall(wsserver_t::connection_ptr& conn, wsserver_t::message_ptr msg)
    {
        // 1. 身份验证，当前客户端是哪个玩家
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr) {
            return;
        }
        // 2. 获取请求信息
        Json::Value response;
        std::string request_body = msg->get_payload();
        Json::Value request_json;
        bool ret = json_util::unserialize(request_body, request_json);
        if (ret == false) {
            response["result"] = false;
            response["reason"] = "请求信息解析失败";
            return ws_response(conn, response);
        }
        // 3. 对于请求进行处理
        if (!request_json["optype"].isNull() && request_json["optype"].asString() == "match_start") {
            // 开始对战匹配：通过匹配模块，将用户添加到匹配队列中
            _mm.add(ssp->get_user());
            response["optype"] = "match_start";
            response["result"] = true;
            return ws_response(conn, response);
        } else if (!request_json["optype"].isNull() && request_json["optype"].asString() == "match_stop") {
            // 停止对战匹配：通过匹配模块，将用户从匹配队列中移除
            _mm.del(ssp->get_user());
            response["optype"] = "match_stop";
            response["result"] = true;
            return ws_response(conn, response);
        }
        // 未知请求信息
        response["optype"] = "unknown";
        response["reason"] = "请求类型未知";
        response["result"] = false;
        return ws_response(conn, response);
    }
    // 游戏房间websocket长连接收到消息处理
    void wsmsg_game_room(wsserver_t::connection_ptr& conn, wsserver_t::message_ptr msg)
    {
        // 1. 获取客户端session识别身份
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr) {
            return;
        }
        // 2. 获取客户端房间信息
        Json::Value response;
        room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
        if (rp.get() == nullptr) {
            response["optype"] = "unknown";
            response["reason"] = "未找到玩家的房间信息";
            response["result"] = false;
            DLOG("房间-没有找到玩家房间信息");
            return ws_response(conn, response);
        }
        // 3. 对消息进行反序列化
        Json::Value request_json;
        std::string request_body = msg->get_payload();
        bool ret = json_util::unserialize(request_body, request_json);
        if (ret == false) {
            response["optype"] = "unknown";
            response["reason"] = "请求解析失败";
            response["result"] = false;
            DLOG("房间-反序列化请求失败");
            return ws_response(conn, response);
        }
        // 4. 通过房间信息进行请求消息的处理
        return rp->handle_requset(request_json);
    }
    // websocket长连接收到消息的回调函数
    void wsmsg_callback(websocketpp::connection_hdl hdl, wsserver_t::message_ptr msg)
    {
        wsserver_t::connection_ptr conn = _wsserver.get_con_from_hdl(hdl);
        websocketpp::http::parser::request request = conn->get_request();
        std::string uri = request.get_uri();
        if (uri == "/hall") {
            // 游戏大厅websocket长连接收到消息处理
            return wsmsg_game_hall(conn, msg);
        } else if (uri == "/room") {
            // 游戏房间websocket长连接收到消息处理
            return wsmsg_game_room(conn, msg);
        }
    }

private:
    // 当传入的是/register.html时，转化为./wwwroot/register.html目录
    std::string _web_root; // 静态资源根目录 ./wwwroot/
    wsserver_t _wsserver;  // websocket服务
    user_table _ut;        // 用户数据表管理
    online_manager _om;    // 在线用户管理
    room_manager _rm;      // 游戏房间管理
    matcher _mm;           // 玩家匹配管理
    session_manager _sm;   // session管理
};